{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "381ef1cd",
   "metadata": {},
   "source": [
    "### 环境初始化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3eb50d38",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 在jupyter notebook里env.render看不到窗口\n",
    "# 写一个helper类，用matplotlib刷新显示图像\n",
    "# 初始化传入env，调用helper的render即可\n",
    "from IPython import display # 导入display模块，用于在Jupyter Notebook中显示图像\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt # 导入matplotlib库，用于绘制图像\n",
    "%matplotlib inline\n",
    "\n",
    "class GymHelper:\n",
    "    def __init__(self, env, figsize = (3, 3)):\n",
    "        self.env = env # 初始化Gym环境\n",
    "        self.figsize = figsize # 初始化绘图窗口大小\n",
    "        \n",
    "        plt.figure(figsize = figsize) # 创建绘图窗口\n",
    "        plt.title(self.env.spec.id if hasattr(env.spec, \"id\") else \"\") # 标题设为环境名\n",
    "        self.img = plt.imshow(env.render()) # 在绘图窗口中显示初始图像\n",
    "    \n",
    "    def render(self, title = None):\n",
    "        image_data = self.env.render() # 获取当前环境图像渲染数据\n",
    "        \n",
    "        self.img.set_data(image_data) # 更新绘图窗口中的图像数据\n",
    "        display.display(plt.gcf()) # 刷新显示\n",
    "        display.clear_output(wait = True) # 有新图片时再清除绘图窗口原有图像\n",
    "        if title: # 如果有标题，就显示标题\n",
    "            plt.title(title)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "dc5faede",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 导入必要的库\n",
    "import gym\n",
    "from gym import spaces\n",
    "import numpy as np\n",
    "import random\n",
    "\n",
    "# 创建贪食蛇SnakeEnv类，继承gym.Env\n",
    "class SnakeEnv(gym.Env):\n",
    "    # 构造函数，参数为grid_size\n",
    "    def __init__(self, grid_size = 16):\n",
    "        super(SnakeEnv, self).__init__()\n",
    "        \n",
    "        # 保存网格大小\n",
    "        self.grid_size = grid_size\n",
    "        # 蛇的初始位置，设为中心点\n",
    "        self.snake = [(self.grid_size // 2, self.grid_size // 2)]\n",
    "\n",
    "        # 定义动作空间，离散的四个值，上下左右\n",
    "        self.action_space = spaces.Discrete(4)\n",
    "        # 定义观测空间，是一个grid*grid*3的三维空间，值域为0到1\n",
    "        self.observation_space = spaces.Box(low=0, high=1, shape=(grid_size, grid_size, 3), dtype=np.uint8)\n",
    "        \n",
    "        # 初始化食物变量\n",
    "        self.food = None\n",
    "        # 蛇行动的总步数\n",
    "        self.steps = 0\n",
    "        # 蛇未吃到食物的步数，可以理解为饥饿度\n",
    "        self.hungry = 0\n",
    "        # 上一步的动作，初始化一个特殊值即可\n",
    "        self.last_action = -10\n",
    "        # 场上食物的数量\n",
    "        self.num_food = 10\n",
    "        # 游戏最大步数\n",
    "        self.max_steps = 200\n",
    "    \n",
    "    # 环境重置函数\n",
    "    def reset(self):\n",
    "        # 蛇回到初始位置\n",
    "        self.snake = [(self.grid_size // 2, self.grid_size // 2)]\n",
    "        # 食物重新生成\n",
    "        self.food = self._generate_food()\n",
    "        # 步数和饥饿度归零\n",
    "        self.steps = 0\n",
    "        self.hungry = 0\n",
    "        # 返回当前状态和一个dict，对齐gym环境中的reset返回值\n",
    "        return self._get_state(), {}\n",
    "\n",
    "    # 动作执行函数\n",
    "    def step(self, action):\n",
    "        # 确定蛇头的位置\n",
    "        head = self.snake[0]\n",
    "        \n",
    "        # 如果蛇试图做和上一步相反的动作，那么保持上一步的动作不变\n",
    "        if abs(action - self.last_action) == 2:\n",
    "            action = self.last_action\n",
    "        \n",
    "        # 根据动作决定蛇头的新位置\n",
    "        if action == 0:   # 上\n",
    "            new_head = (head[0]-1, head[1])\n",
    "        elif action == 1: # 右\n",
    "            new_head = (head[0], head[1]+1)\n",
    "        elif action == 2: # 下\n",
    "            new_head = (head[0]+1, head[1])\n",
    "        else:              # 左\n",
    "            new_head = (head[0], head[1]-1)\n",
    "        \n",
    "        # 记录这一步的动作，并且步数+1\n",
    "        self.last_action = action\n",
    "        self.steps += 1\n",
    "\n",
    "        # 如果蛇头的新位置在蛇身上，游戏结束，返回-100的奖励\n",
    "        if new_head in self.snake:\n",
    "            return self._get_state(), -100, True, self.steps>=self.max_steps, {}\n",
    "        # 如果蛇头的新位置出界了，游戏结束，返回-200的奖励\n",
    "        if self._is_out_of_bounds(new_head):\n",
    "            return self._get_state(), -200, True, self.steps>=self.max_steps, {}\n",
    "        elif new_head in self.food: # 如果新蛇头位置有食物\n",
    "            # 在蛇体数组的最前面插入一节蛇头的新位置\n",
    "            self.snake.insert(0, new_head)\n",
    "            # 重新生成食物\n",
    "            self.food = self._generate_food()\n",
    "            # 饥饿度归零\n",
    "            self.hungry = 0\n",
    "            # 游戏继续，返回50的奖励\n",
    "            return self._get_state(), 50, False, self.steps>=self.max_steps, {}\n",
    "        else: # 没有食物，且游戏也没有触发结束条件\n",
    "            # 在蛇体数组的最前面插入一节蛇头的新位置\n",
    "            self.snake.insert(0, new_head)\n",
    "            # 去掉最后一节\n",
    "            self.snake.pop()\n",
    "            \n",
    "            # 默认奖励为0，饥饿度增加，如果饥饿度达到20，则每步给予一个负奖励\n",
    "            r = 0\n",
    "            self.hungry += 1\n",
    "            if self.hungry >= 20:\n",
    "                r -= (1 + (self.hungry - 20) / 100)\n",
    "            \n",
    "            # 返回对应结果\n",
    "            return self._get_state(), r, False, self.steps>=self.max_steps, {}\n",
    "    \n",
    "    # 从动作空间随机选取一个动作\n",
    "    def sample(self):\n",
    "        return self.action_space.sample()\n",
    "    \n",
    "    # 渲染游戏界面，返回图像数组\n",
    "    def render(self, mode='rgb_array'):\n",
    "        # 初始化画布\n",
    "        img = np.zeros((self.grid_size, self.grid_size, 3))\n",
    "\n",
    "        # 绘制蛇体，蛇头是红色，蛇身是蓝色\n",
    "        for i, s in enumerate(self.snake):\n",
    "            if i == 0:\n",
    "                img[s] = [1, 0, 0]\n",
    "            else:\n",
    "                img[s] = [0, 0, 1]\n",
    "\n",
    "        # 食物设为绿色\n",
    "        for f in self.food:\n",
    "            img[f] = [0, 1, 0]\n",
    "\n",
    "        # 返回图像\n",
    "        return img\n",
    "\n",
    "    # state直接就是图像数组\n",
    "    def _get_state(self):\n",
    "        return self.render()\n",
    "    \n",
    "    # 判断某个位置是否出界\n",
    "    def _is_out_of_bounds(self, position):\n",
    "        x, y = position\n",
    "        return x < 0 or y < 0 or x >= self.grid_size or y >= self.grid_size\n",
    "\n",
    "    # 生成食物\n",
    "    def _generate_food(self):\n",
    "        foods = []\n",
    "        while True:\n",
    "            # 每次生成一个食物\n",
    "            food = (random.randint(0, self.grid_size-1), random.randint(0, self.grid_size-1))\n",
    "            # 既不能在蛇身上，也不能在已有的食物上\n",
    "            if food not in self.snake and food not in foods:\n",
    "                foods.append(food)\n",
    "            # 生成数量足够的食物则返回\n",
    "            if len(foods) >= self.num_food:\n",
    "                return foods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "29cbd0de",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 300x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 导入gym库\n",
    "import gym\n",
    "\n",
    "# 创建环境\n",
    "env = SnakeEnv()\n",
    "# 重置环境\n",
    "env.reset()\n",
    "# 创建GymHelper\n",
    "gym_helper = GymHelper(env)\n",
    "\n",
    "# 循环N次\n",
    "for i in range(20):\n",
    "    gym_helper.render(title = str(i)) # 渲染环境\n",
    "    action = env.action_space.sample() # 从动作空间中随机选取一个动作\n",
    "    observation, reward, terminated, truncated, info = env.step(action) # 执行动作\n",
    "    if terminated or truncated: # 如果游戏结束，则结束循环\n",
    "        break\n",
    "\n",
    "# 游戏结束\n",
    "gym_helper.render(title = \"Finished\")\n",
    "# 关闭环境\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8bde9aac",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((16, 16, 3), 0, False, False, {})"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 查看五元组\n",
    "observation.shape, reward, terminated, truncated, info"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50222c97",
   "metadata": {},
   "source": [
    "### PPO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b80ab0f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 导入必要的库\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "\n",
    "import numpy as np\n",
    "import sys\n",
    "import time\n",
    "import random\n",
    "import collections\n",
    "from tqdm import * # 用于显示进度条\n",
    "\n",
    "# 策略模型，给定状态生成各个动作的概率\n",
    "class PolicyModel(nn.Module):\n",
    "    def __init__(self, grid_size, output_dim):\n",
    "        super(PolicyModel, self).__init__()\n",
    "        self.grid_size = grid_size\n",
    "        \n",
    "        # 定义卷积层\n",
    "        self.conv = nn.Sequential(\n",
    "            nn.Conv2d(3, 8, kernel_size=1), # 使用1x1卷积升维\n",
    "            nn.BatchNorm2d(8),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(8, 4, kernel_size=1), # 使用1x1卷积降维\n",
    "            nn.BatchNorm2d(4),\n",
    "            nn.ReLU()\n",
    "        )\n",
    "        \n",
    "        # 使用全连接层构建一个简单的神经网络，ReLU作为激活函数\n",
    "        # 最后加一个Softmax层，使得输出可以看作是概率分布\n",
    "        self.fc = nn.Sequential(\n",
    "            nn.Flatten(), # 将特征图展开为一维向量\n",
    "            nn.Linear(grid_size * grid_size * 4, 256),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(256, 256),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(256, output_dim),\n",
    "            nn.Softmax(dim = 1)\n",
    "        )\n",
    "\n",
    "    # 定义前向传播，输出动作概率分布\n",
    "    def forward(self, x):\n",
    "        x = x.view(-1, 3, self.grid_size, self.grid_size)\n",
    "        x = self.conv(x)\n",
    "        action_prob = self.fc(x)\n",
    "        return action_prob\n",
    "\n",
    "# 价值模型，给定状态估计价值\n",
    "class ValueModel(nn.Module):\n",
    "    def __init__(self, grid_size):\n",
    "        super(ValueModel, self).__init__()\n",
    "        self.grid_size = grid_size\n",
    "        \n",
    "        # 定义卷积层\n",
    "        self.conv = nn.Sequential(\n",
    "            nn.Conv2d(3, 8, kernel_size=1), # 使用1x1卷积升维\n",
    "            nn.BatchNorm2d(8),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(8, 4, kernel_size=1), # 使用1x1卷积降维\n",
    "            nn.BatchNorm2d(4),\n",
    "            nn.ReLU()\n",
    "        )\n",
    "        \n",
    "        # 网络结构和策略模型类似，输出维度为动作空间的维度\n",
    "        self.fc = nn.Sequential(\n",
    "            nn.Flatten(), # 将特征图展开为一维向量\n",
    "            nn.Linear(grid_size * grid_size * 4, 256),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(256, 256),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(256, 1)\n",
    "        )\n",
    "\n",
    "    # 定义前向传播，输出价值估计\n",
    "    def forward(self, x):\n",
    "        x = x.view(-1, 3, self.grid_size, self.grid_size)\n",
    "        x = self.conv(x)\n",
    "        value = self.fc(x)\n",
    "        return value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b74e5d0c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义PPO类\n",
    "class PPO:\n",
    "    # 构造函数，参数包含环境，学习率，折扣因子，优势计算参数，clip参数，训练轮数\n",
    "    def __init__(self, env, learning_rate=0.00002, gamma=0.99, lamda=0.95, clip_eps=0.1, epochs=10):\n",
    "        self.env = env\n",
    "        self.gamma = gamma\n",
    "        self.lamda = lamda\n",
    "        self.clip_eps = clip_eps\n",
    "        self.epochs = epochs\n",
    "\n",
    "        # 判断可用的设备是 CPU 还是 GPU\n",
    "        self.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "        # 根据环境的观测空间和动作空间，定义策略模型和价值模型，并将模型移动到指定设备上\n",
    "        self.policy_model = PolicyModel(env.observation_space.shape[0], env.action_space.n).to(self.device)\n",
    "        self.value_model = ValueModel(env.observation_space.shape[0]).to(self.device)\n",
    "\n",
    "        # 定义Adam优化器\n",
    "        self.policy_optimizer = torch.optim.Adam(self.policy_model.parameters(), lr=learning_rate)\n",
    "        self.value_optimizer = torch.optim.Adam(self.value_model.parameters(), lr=learning_rate)\n",
    "    \n",
    "    # 使用策略模型生成动作概率分布并采样\n",
    "    def choose_action(self, state):\n",
    "        # 将状态转换为tensor输入模型\n",
    "        state = torch.FloatTensor(np.array([state])).to(self.device)\n",
    "        with torch.no_grad():\n",
    "            action_prob = self.policy_model(state)\n",
    "        \n",
    "        # 生成分布后采样返回动作\n",
    "        c = torch.distributions.Categorical(action_prob)\n",
    "        action = c.sample()\n",
    "        return action.item()\n",
    "    \n",
    "    # 广义优势估计\n",
    "    def calc_advantage(self, td_delta):\n",
    "        # 将TD误差转换为numpy数组\n",
    "        td_delta = td_delta.cpu().detach().numpy()\n",
    "        # 初始化优势函数值及存储优势值的列表\n",
    "        advantage = 0\n",
    "        advantage_list = []\n",
    "        # 反向遍历，从最后一步开始倒推\n",
    "        for r in td_delta[::-1]:\n",
    "            # 将当前步的TD误差及上一步优势加权值作为当前步的优势\n",
    "            advantage = r + self.gamma * self.lamda * advantage\n",
    "            # 将优势值加到列表开头，最终得到顺序序列\n",
    "            advantage_list.insert(0, advantage)\n",
    "        # 转换为tensor后返回\n",
    "        return torch.FloatTensor(np.array(advantage_list)).to(self.device)\n",
    "    \n",
    "    # 模型更新\n",
    "    def update(self, buffer):\n",
    "        # 取出数据，并将其转换为numpy数组\n",
    "        # 然后进一步转换为tensor，并将数据转移到指定计算资源设备上\n",
    "        states, actions, rewards, next_states, dones = zip(*buffer)\n",
    "        states = torch.FloatTensor(np.array(states)).to(self.device)\n",
    "        actions = torch.tensor(np.array(actions)).view(-1, 1).to(self.device)\n",
    "        rewards = torch.FloatTensor(np.array(rewards)).view(-1, 1).to(self.device)\n",
    "        next_states = torch.FloatTensor(np.array(next_states)).to(self.device)\n",
    "        dones = torch.FloatTensor(np.array(dones)).view(-1, 1).to(self.device)\n",
    "\n",
    "        with torch.no_grad():\n",
    "            # 计算旧策略下的动作概率\n",
    "            old_action_prob = torch.log(self.policy_model(states).gather(1, actions))\n",
    "            \n",
    "            # 计算TD目标及误差\n",
    "            td_target = rewards + (1 - dones) * self.gamma * self.value_model(next_states)\n",
    "            td_delta = td_target - self.value_model(states)\n",
    "        \n",
    "        # 优势估计\n",
    "        advantage = self.calc_advantage(td_delta)\n",
    "        \n",
    "        # 多步更新策略\n",
    "        for i in range(self.epochs):\n",
    "            # 计算新策略下的动作概率\n",
    "            action_prob = torch.log(self.policy_model(states).gather(1, actions))\n",
    "            # 计算策略动作概率比\n",
    "            ratio = torch.exp(action_prob - old_action_prob)\n",
    "            \n",
    "            # CLIP修剪\n",
    "            part1 = ratio * advantage\n",
    "            part2 = torch.clamp(ratio, 1 - self.clip_eps, 1 + self.clip_eps) * advantage\n",
    "            # 计算策略损失\n",
    "            policy_loss = -torch.min(part1, part2).mean()\n",
    "            # 计算价值损失\n",
    "            value_loss = F.mse_loss(self.value_model(states), td_target).mean()\n",
    "            \n",
    "            # 梯度清零、反向传播、更新参数\n",
    "            self.policy_optimizer.zero_grad()\n",
    "            self.value_optimizer.zero_grad()\n",
    "            policy_loss.backward()\n",
    "            value_loss.backward()\n",
    "            self.policy_optimizer.step()\n",
    "            self.value_optimizer.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "916cff5e",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode 0: -210.45                       \n",
      "Episode 1000: -180.51                               \n",
      "Episode 2000: -150                                  \n",
      "Episode 3000: -150                                  \n",
      "Episode 4000: -180.91                               \n",
      "Episode 5000: -161.55                               \n",
      "Episode 6000: 100                                   \n",
      "Episode 7000: -167.2                                \n",
      "Episode 8000: -150                                  \n",
      "Episode 9000: -205.1                                \n",
      "100%|██████████| 10000/10000 [11:53<00:00, 14.01it/s]\n"
     ]
    }
   ],
   "source": [
    "# 定义超参数\n",
    "max_episodes = 10000 # 训练episode数\n",
    "max_steps = 200 # 每个回合的最大步数\n",
    "\n",
    "# 创建PPO对象\n",
    "agent = PPO(env)\n",
    "# 定义保存每个回合奖励的列表\n",
    "episode_rewards = []\n",
    "\n",
    "# 开始循环，tqdm用于显示进度条并评估任务时间开销\n",
    "for episode in tqdm(range(max_episodes), file=sys.stdout):\n",
    "    # 重置环境并获取初始状态\n",
    "    state, _ = env.reset()\n",
    "    # 当前回合的奖励\n",
    "    episode_reward = 0\n",
    "    # 记录每个episode的信息\n",
    "    buffer = []\n",
    "\n",
    "    # 循环进行每一步操作\n",
    "    for step in range(max_steps):\n",
    "        # 根据当前状态选择动作\n",
    "        action = agent.choose_action(state)\n",
    "        # 执行动作，获取新的信息\n",
    "        next_state, reward, terminated, truncated, info = env.step(action)\n",
    "        # 判断是否达到终止状态\n",
    "        done = terminated or truncated\n",
    "        \n",
    "        # 将这个五元组加到buffer中\n",
    "        buffer.append((state, action, reward, next_state, done))\n",
    "        # 累计奖励\n",
    "        episode_reward += reward\n",
    "        \n",
    "        # 更新当前状态\n",
    "        state = next_state\n",
    "\n",
    "        if done:\n",
    "            break\n",
    "    \n",
    "    # 更新策略\n",
    "    agent.update(buffer)\n",
    "    # 记录当前回合奖励值\n",
    "    episode_rewards.append(episode_reward)\n",
    "    \n",
    "    # 打印中间值\n",
    "    if episode % (max_episodes // 10) == 0:\n",
    "        tqdm.write(\"Episode \" + str(episode) + \": \" + str(episode_reward))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "94aeebdd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用Matplotlib绘制奖励值的曲线图\n",
    "plt.plot(episode_rewards[::50])\n",
    "plt.title(\"reward\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "06a37b9a",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 300x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 重置环境，开始新的一轮游戏\n",
    "observation, _ = env.reset()\n",
    "# 创建GymHelper对象来辅助显示\n",
    "gym_helper = GymHelper(env, figsize = (3, 3))\n",
    "\n",
    "# 开始游戏\n",
    "for i in range(200):\n",
    "    # 渲染环境，title为当前步骤数\n",
    "    gym_helper.render(title = str(i))\n",
    "    \n",
    "    # 找到当前状态下的最优动作\n",
    "    action = agent.choose_action(observation)\n",
    "    # 执行action，获取新的信息\n",
    "    observation, reward, terminated, truncated, info = env.step(action)\n",
    "    \n",
    "    # 如果游戏结束，则结束当前循环\n",
    "    if terminated or truncated:\n",
    "        break\n",
    "\n",
    "# 游戏结束\n",
    "gym_helper.render(title = \"Finished\")\n",
    "# 关闭环境\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c87d2206",
   "metadata": {},
   "source": [
    "### 进一步探索"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "0d572eb0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "observation shape: (96, 96, 3)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 300x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 导入gym库\n",
    "import gym\n",
    "\n",
    "# 创建环境，指定渲染模式为rgb_array，如果是在IDE中可以改为'human'\n",
    "env = gym.make('CarRacing-v2', render_mode='rgb_array')\n",
    "# 重置环境\n",
    "env.reset()\n",
    "# 创建GymHelper\n",
    "gym_helper = GymHelper(env)\n",
    "\n",
    "# 循环N次\n",
    "for i in range(50):\n",
    "    gym_helper.render(title = str(i)) # 渲染环境\n",
    "    action = env.action_space.sample() # 从动作空间中随机选取一个动作\n",
    "    observation, reward, terminated, truncated, info = env.step(action) # 执行动作\n",
    "    if terminated or truncated: # 如果游戏结束，则结束循环\n",
    "        break\n",
    "\n",
    "# 游戏结束\n",
    "gym_helper.render(title = \"Finished\")\n",
    "# 关闭环境\n",
    "env.close()\n",
    "# 打印观测空间shape\n",
    "print(\"observation shape:\", observation.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "3a73b036",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "observation shape: (210, 160, 3)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 300x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 导入gym库\n",
    "import gym\n",
    "from ale_py import ALEInterface\n",
    "from ale_py.roms import Breakout\n",
    "\n",
    "# 创建ALE接口实例，加载对应ROM\n",
    "ale = ALEInterface()\n",
    "ale.loadROM(Breakout)\n",
    "\n",
    "# 创建环境，指定渲染模式为rgb_array，如果是在IDE中可以改为'human'\n",
    "env = gym.make('ALE/Breakout-v5', render_mode='rgb_array')\n",
    "# 重置环境\n",
    "env.reset()\n",
    "# 创建GymHelper\n",
    "gym_helper = GymHelper(env)\n",
    "\n",
    "# 循环N次\n",
    "for i in range(50):\n",
    "    gym_helper.render(title = str(i)) # 渲染环境\n",
    "    action = env.action_space.sample() # 从动作空间中随机选取一个动作\n",
    "    observation, reward, terminated, truncated, info = env.step(action) # 执行动作\n",
    "    if terminated or truncated: # 如果游戏结束，则结束循环\n",
    "        break\n",
    "\n",
    "# 游戏结束\n",
    "gym_helper.render(title = \"Finished\")\n",
    "# 关闭环境\n",
    "env.close()\n",
    "# 打印观测空间shape\n",
    "print(\"observation shape:\", observation.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b3c7cac3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "observation shape: (210, 160, 3)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 300x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 导入gym库\n",
    "import gym\n",
    "from ale_py import ALEInterface\n",
    "from ale_py.roms import Tennis\n",
    "\n",
    "# 创建ALE接口实例，加载对应ROM\n",
    "ale = ALEInterface()\n",
    "ale.loadROM(Tennis)\n",
    "\n",
    "# 创建环境，指定渲染模式为rgb_array，如果是在IDE中可以改为'human'\n",
    "env = gym.make('ALE/Tennis-v5', render_mode='rgb_array')\n",
    "# 重置环境\n",
    "env.reset()\n",
    "# 创建GymHelper\n",
    "gym_helper = GymHelper(env)\n",
    "\n",
    "# 循环N次\n",
    "for i in range(50):\n",
    "    gym_helper.render(title = str(i)) # 渲染环境\n",
    "    action = env.action_space.sample() # 从动作空间中随机选取一个动作\n",
    "    observation, reward, terminated, truncated, info = env.step(action) # 执行动作\n",
    "    if terminated or truncated: # 如果游戏结束，则结束循环\n",
    "        break\n",
    "\n",
    "# 游戏结束\n",
    "gym_helper.render(title = \"Finished\")\n",
    "# 关闭环境\n",
    "env.close()\n",
    "# 打印观测空间shape\n",
    "print(\"observation shape:\", observation.shape)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
